Return of the Great Spaghetti Monster : Learnings from a Twelve-Year Adventure in Web Software Development

The widespread adoption of the World Wide Web has fundamentally changed the landscape of software development. Only ten years ago, very few developers would write software for the Web, let alone consider using JavaScript or other web technologies for writing any serious software applications. In this paper, we reflect upon a twelve-year adventure in web development that began with the development of the Lively Kernel system at Sun Microsystems Labs in 2006. Back then, we also published some papers that identified important challenges in web-based software development based on established software engineering principles. We will revisit our earlier findings and compare the state of the art in web development today to our earlier learnings, followed by some reflections and suggestions for the road forward.Peer reviewe

Acceptance Criteria for Critical Software Based on Testability Estimates and Test Results

Testability is defined as the probability that a program will fail a test, conditional on the program containing some fault. In this paper, we show that statements about the testability of a program can be more simply described in terms of assumptions on the probability distribution of the failure intensity of the program. We can thus state general acceptance conditions in clear mathematical terms using Bayesian inference. We develop two scenarios, one for software for which the reliability requirements are that the software must be completely fault-free, and another for requirements stated as an upper bound on the acceptable failure probability

Assessing Code Authorship: The Case of the Linux Kernel

Code authorship is a key information in large-scale open source systems. Among others, it allows maintainers to assess division of work and identify key collaborators. Interestingly, open-source communities lack guidelines on how to manage authorship. This could be mitigated by setting to build an empirical body of knowledge on how authorship-related measures evolve in successful open-source communities. Towards that direction, we perform a case study on the Linux kernel. Our results show that: (a) only a small portion of developers (26 %) makes significant contributions to the code base; (b) the distribution of the number of files per author is highly skewed --- a small group of top authors (3 %) is responsible for hundreds of files, while most authors (75 %) are responsible for at most 11 files; (c) most authors (62 %) have a specialist profile; (d) authors with a high number of co-authorship connections tend to collaborate with others with less connections.Comment: Accepted at 13th International Conference on Open Source Systems (OSS). 12 page

formal methods and agile development towards a happy marriage

Change makes software different from any other artifact created by humans. Although this is known since the 1970s, change is still often handled in an ad hoc manner. Agile development and, more recently, DevOps have been proposed as a solution, and success stories are reported from industry. Still, principled and rigorous foundations that can be taught, practiced, and systematically replicated are lacking. We argue that change has to become a first-class concept and that the development tools used by engineers and the run time environment supporting software execution should be structured in a way that naturally accommodates change. We distinguish between evolution and adaptation and discuss how software can be made self-adaptive, and how it can cooperate with humans in-the-loop, supporting continuous verification and assuring dependability. We discuss how several research approaches that were investigated in the past decade may be integrated and extended in a roadmap of future work leading to progress in tool support and automation to achieve dependable adaptation and evolution

Client-Side Cornucopia : Comparing the Built-In Application Architecture Models in the Web Browser

Peer reviewe

Conversations About Responsible Nanoresearch

There is currently a strong focus on responsible research in relation to the development of nanoscience and nanotechnology. This study presents a series of conversations with nanoresearchers, with the ‘European Commission recommendation on a code of conduct for responsible nanosciences and nanotechnologies research’ (EC-CoC) as its point of departure. Six types of reactions to the document are developed, illustrating the diversity existing within the scientific community in responses towards this kind of new approaches to governance. Three broad notions of responsible nanoresearch are presented. The article concludes by arguing that while the suggestion put forward in the EC-CoC brings the concept of responsible nanoresearch a long way, one crucial element is to be wanted, namely responsible nanoresearch as increased awareness of moral choices

Comparing Static and Dynamic Weighted Software Coupling Metrics

Coupling metrics that count the number of inter-module connections in a software system are an established way to measure internal software quality with respect to modularity. In addition to static metrics, which are obtained from the source or compiled code of a program, dynamic metrics use runtime data gathered, e.g., by monitoring a system in production. Dynamic metrics have been used to improve the accuracy of static metrics for object-oriented software. We study weighted dynamic coupling that takes into account how often a connection (e.g., a method call) is executed during a system’s run. We investigate the correlation between dynamic weighted metrics and their static counterparts. To compare the different metrics, we use data collected from four different experiments, each monitoring production use of a commercial software system over a period of four weeks. We observe an unexpected level of correlation between the static and the weighted dynamic case as well as revealing differences between class- and package-level analyses

Assessing architectural evolution: A case study

This is the post-print version of the Article. The official published can be accessed from the link below - Copyright @ 2011 SpringerThis paper proposes to use a historical perspective on generic laws, principles, and guidelines, like Lehman’s software evolution laws and Martin’s design principles, in order to achieve a multi-faceted process and structural assessment of a system’s architectural evolution. We present a simple structural model with associated historical metrics and visualizations that could form part of an architect’s dashboard. We perform such an assessment for the Eclipse SDK, as a case study of a large, complex, and long-lived system for which sustained effective architectural evolution is paramount. The twofold aim of checking generic principles on a well-know system is, on the one hand, to see whether there are certain lessons that could be learned for best practice of architectural evolution, and on the other hand to get more insights about the applicability of such principles. We find that while the Eclipse SDK does follow several of the laws and principles, there are some deviations, and we discuss areas of architectural improvement and limitations of the assessment approach

ESPRESO-W, ein Werkzeug für die Spezifikation von Prozeßrechner-Software

ESPRESO (System zur Darstellung der Sezifikation von Prozeßrechner-Software) ist ein rechnerunterstütztes Spezifikationssystem, das spezielle Anforderungen der Spezifikation von Prozeßrechner-Software berücksichtigt. Die Komponenten von ESPRESO sind eine formale Sprache ESPRESO-S und ein Programmsystem ESPRESO-W. Im vorliegenden Beitrag werden die wesentlichen Aspekte von ESPRESO-S kurz zusammengefaßt. Danach werden Konzeption und Aufbau von ESPRESO-W und Probleme seiner Implementierung ausführlich dargestellt